/**
 * 任务选项 composable
 * 统一管理任务模块的优先级选项
 * 从接口获取数据，避免硬编码
 * 使用全局共享状态，避免多个组件重复调用接口
 */
import { ref, computed } from 'vue'
import { priorityApi } from '@/api/priority'
import { useTaskStates } from './useTaskStates'

interface TaskOptionItem {
  code: string
  name: string
  color: string
  description?: string
  sort_order?: number
}

// 全局共享状态（单例模式）
const globalState = {
  // 选项数据
  priorityOptions: ref<TaskOptionItem[]>([]),
  loading: ref(false),
  error: ref<string | null>(null),
  
  // 缓存和去重
  loadingPromise: null as Promise<void> | null,
  lastLoadTime: 0,
  cacheDuration: 5 * 60 * 1000, // 5分钟缓存
  
  // 是否已初始化
  initialized: false
}

// 默认优先级选项（作为后备方案，仅在API加载失败时使用）
// 注意：这些值应该与后端默认优先级配置保持一致
// 实际使用时应该从优先级管理API获取，而不是硬编码
const defaultPriorityOptions: TaskOptionItem[] = [
  { code: 'lowest', name: '最低', color: '#909399' },
  { code: 'low', name: '低', color: '#67C23A' },
  { code: 'medium', name: '中', color: '#E6A23C' },
  { code: 'high', name: '高', color: '#F56C6C' },
  { code: 'highest', name: '最高', color: '#F56C6C' }
]

export function useTaskOptions() {
  const { statusOptions: taskStatusOptions, loadStates: loadTaskStates } = useTaskStates()
  
  // 使用全局共享状态
  const priorityOptions = globalState.priorityOptions
  const loading = globalState.loading
  const error = globalState.error

  // 计算属性：状态选项（从 useTaskStates 获取）
  const statusOptions = computed(() => {
    return taskStatusOptions.value.map(s => ({
      code: s.value,
      name: s.label,
      color: s.color || '#909399',
      description: undefined
    }))
  })

  // 计算属性：优先级选项（格式化）
  const formattedPriorityOptions = computed(() => {
    // 不使用备用硬编码数据，只使用从API获取的数据
    return priorityOptions.value
      .filter(p => p && p.code && p.name) // 过滤掉无效的选项
      .map(p => ({
        value: String(p.code || ''),
        label: String(p.name || ''),
        color: p.color || '#909399',
        description: p.description
      }))
      .filter(opt => opt.value && opt.label) // 再次过滤确保 value 和 label 都不为空
  })

  // 根据代码获取优先级名称
  const getPriorityName = (code: string) => {
    const option = priorityOptions.value.find(p => p.code === code)
    if (option) return option.name
    // 不使用备用硬编码数据，直接返回代码
    return code
  }

  // 根据代码获取优先级颜色
  const getPriorityColor = (code: string) => {
    const option = priorityOptions.value.find(p => p.code === code)
    if (option) return option.color
    // 不使用备用硬编码数据，返回默认颜色
    return '#909399'
  }

  // 根据代码获取优先级类型（用于 Element Plus tag type）
  const getPriorityType = (code: string): 'info' | 'success' | 'warning' | 'danger' | 'primary' => {
    const color = getPriorityColor(code)
    // 将颜色转换为 Element Plus 的 tag type
    const colorMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      '#67C23A': 'success',
      '#E6A23C': 'warning',
      '#F56C6C': 'danger',
      '#409EFF': 'primary',
      '#909399': 'info',
      '#C0C4CC': 'info'
    }
    // 尝试匹配颜色
    for (const [colorKey, type] of Object.entries(colorMap)) {
      if (color.toLowerCase() === colorKey.toLowerCase()) {
        return type
      }
    }
    // 回退到基于代码的默认映射
    const codeMap: Record<string, 'info' | 'success' | 'warning' | 'danger' | 'primary'> = {
      lowest: 'info',
      low: 'info',
      medium: 'warning',
      high: 'warning',
      highest: 'danger'
    }
    return codeMap[code.toLowerCase()] || 'info'
  }

  // 获取默认优先级
  const defaultPriority = computed(() => {
    // 优先返回中等优先级，如果没有则返回第一个，不使用备用硬编码数据
    return priorityOptions.value.find(p => p.code === 'medium') || priorityOptions.value[0] || null
  })

  // 加载所有选项数据（带缓存和去重）
  const loadOptions = async (forceRefresh = false) => {
    // 如果正在加载中，返回现有的 Promise，避免重复请求
    if (globalState.loadingPromise && !forceRefresh) {
      return globalState.loadingPromise
    }
    
    // 检查缓存是否有效
    const now = Date.now()
    const isCacheValid = !forceRefresh && 
                        globalState.initialized && 
                        (now - globalState.lastLoadTime) < globalState.cacheDuration &&
                        priorityOptions.value.length > 0
    
    if (isCacheValid) {
      return Promise.resolve()
    }
    
    // 创建加载 Promise
    const loadPromise = (async () => {
      try {
        loading.value = true
        error.value = null

        // 加载状态数据（使用 useTaskStates）
        await loadTaskStates()

        // 尝试从 API 加载优先级选项
        try {
          const response = await priorityApi.getAll('task')
          
          if (response.data && response.data.success && response.data.data) {
            const priorities = Array.isArray(response.data.data) ? response.data.data : []
            priorityOptions.value = priorities
              .filter((p: any) => p && (p.code || p.value)) // 过滤掉无效数据
              .map((p: any) => ({
                code: String(p.code || p.value || ''),
                name: String(p.name || p.label || ''),
                color: p.color || '#909399',
                description: p.description,
                sort_order: p.sort_order || 0
              }))
              .filter((p: any) => p.code && p.name) // 再次过滤确保 code 和 name 都不为空
          } else if (response.data && Array.isArray(response.data)) {
            // 如果直接返回数组
            priorityOptions.value = response.data
              .filter((p: any) => p && (p.code || p.value)) // 过滤掉无效数据
              .map((p: any) => ({
                code: String(p.code || p.value || ''),
                name: String(p.name || p.label || ''),
                color: p.color || '#909399',
                description: p.description,
                sort_order: p.sort_order || 0
              }))
              .filter((p: any) => p.code && p.name) // 再次过滤确保 code 和 name 都不为空
          }
        } catch (priorityError) {
          console.warn('从 API 获取任务优先级失败:', priorityError)
          // 不使用备用硬编码数据，保持 priorityOptions.value 为空数组
        }
        
        // 更新缓存信息
        globalState.lastLoadTime = now
        globalState.initialized = true
      } catch (err: any) {
        console.error('加载任务选项失败:', err)
        error.value = err.message || '加载任务选项失败'
        
        // 不使用备用硬编码数据，如果加载失败，保持选项为空数组
      } finally {
        loading.value = false
        globalState.loadingPromise = null
      }
    })()
    
    // 保存 Promise 以便其他调用可以等待
    globalState.loadingPromise = loadPromise
    
    return loadPromise
  }

  return {
    // 原始数据
    statusOptions,
    
    // 格式化后的选项（用于下拉框）
    priorityOptions: formattedPriorityOptions,
    formattedPriorityOptions,
    
    // 状态
    loading,
    error,
    
    // 默认值
    defaultPriority,
    
    // 工具函数
    getPriorityName,
    getPriorityColor,
    getPriorityType,
    
    // 加载方法
    loadOptions
  }
}

